public class XianC {
//    public static void main(String[] args) {
//        System.out.println("11111");
//        Thread t = new Thread(){
//            public void run(){
//                System.out.println("22222222222");
//                try{
//                    Thread.sleep(10);
//                }catch (Exception e) {}
//                    System.out.println("3333333333333");
//
//            }
//        };
//        t.start();
//        try{
//            Thread.sleep(9);
//        }catch (Exception e){}
//        System.out.println("444444444444444");
//    }

    /**
     * 程序的入口点
     * 创建并启动一个自定义线程，然后演示如何中断它
     *
     * @param args 命令行参数
     */
//    public static void main(String[] args) {
//        // 创建自定义线程实例
//        Thread t = new MyThread();
//        // 启动线程
//        t.start();
//        try {
//            // 让当前线程暂停10毫秒，以演示后续的中断操作
//            Thread.sleep(5);
//            // 尝试中断线程t
//            t.interrupt();
//            // 等待线程t结束
//            t.join();
//            // 打印主线程结束信息
//            System.out.println("main线程结束");
//        } catch (InterruptedException e) {
//            // 捕获中断异常并打印堆栈跟踪
//            e.printStackTrace();
//        }
//    }
    public static void main(String[] args) throws InterruptedException{
       Add a = new Add();
       Jian j = new Jian();
       a.start();
       j.start();
       a.join();
       j.join();
        System.out.println("count="+Count.count);

    }

}
/**
 * Count 类用于共享计数器和同步锁
 */
class Count {
    // 公有静态对象，用作线程同步的锁
    public static final Object lock = new Object();
    // 公有静态变量，用于记录当前计数
    public static int count = 0;
}

/**
 * Add 类继承自 Thread，用于增加计数器的值
 * 它通过多次执行来增加计数器的值，每次增加 1
 */
class Add extends Thread {
    /**
     * 线程的入口点
     * 在一个循环中，总共增加计数器 1000 次
     * 使用 Count.lock 作为同步锁，以确保线程安全
     */
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (Count.lock) {
                Count.count += 1;
            }
            System.out.println("加释放");
        }
    }
}

/**
 * Jian 类继承自 Thread，用于减少计数器的值
 * 它通过多次执行来减少计数器的值，每次减少 1
 */
class Jian extends Thread {
    /**
     * 线程的入口点
     * 在一个循环中，总共减少计数器 1000 次
     * 使用 Count.lock 作为同步锁，以确保线程安全
     */
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (Count.lock) {
                Count.count -= 1;
            }
            System.out.println("减释放");
        }

    }
}

// 自定义线程类，继承自Thread
//class MyThread extends Thread{
//    /**
//     * 线程的运行体
//     * 只要线程未被中断，就持续执行任务
//     */
//    @Override
//    public void run(){
//        int n =0;
//        // 循环执行任务，直到线程被中断
//        while(! isInterrupted()) {
//            n++;
//            // 打印启动线程的次数
//            System.out.println(n+"启动线程");
//        }
//    }
//}

